Caching is an often-used tool to aide in performance of algorithms and software. Any given value in cache also has a context in which that value is the correct value.
Relatively simple methods use patterns like memoization. In memoization, a function call is provided with remembered inputs. The function call returns the remembered result (that is remembered for those inputs) without re-calculating the result. In memoization, the context in which the cached value is correct is always the same for the given input parameters.
However, caching strategies such as memoization become problematic when additional information, outside of the calling method, is also needed to determine whether the cached information is correct. For example, a system may derive tax rate information, and cache that information. If any information (including the company's address or tax rate information or dozens of other things) change, then the cache needs to be invalidated.
Many current software systems handle this by explicitly invalidating all applicable caches at the point when the data changes. However, this approach forces the item being changed to know about all consumers who are caching that information, so that those caches can be invalidated. This can lead to unnecessary coupling between the items being changed and the consumers, and it can also lead to undesirable circular dependencies.
Another approach that has been used to handle such problems is by creating event subscriptions to changes. However, this means that any new types of changes that invalidate caching will require that the cache subscribe to them.
Yet another approach to this is to simply mass-invalidate all caches in the system when any change is made. However, this can be problematic because even very static data in a large system is likely changing fairly often. Therefore, a mass-invalidation on all changes can become extremely expensive.
These high costs of cache management in complex problems mean that many times developers do not employ caching even when it would be beneficial, because the cost of ensuring correctness of the cache is so high. Continuing on with the above-mentioned example of caching tax derivation information, there can be hundreds of aspects that go into tax derivation. Attempting to invalidate the cached results from changes to any of these aspects is very difficult. Therefore, even though tax setup information changes very infrequently, software systems often continually re-derive information that could have been cached just in case any of the information has changed.
The discussion above is merely provided for general background information and is not intended to be used as an aid in determining the scope of the claimed subject matter.